Left Termination of the query pattern balance_in_2(g, a) w.r.t. the given Prolog program could successfully be proven:



↳ Prolog
  ↳ PrologToPiTRSProof

Clauses:

balance(T, TB) :- balance55(T, XX0, XX1, [], .(','(nil, -(XX0, XX0)), XX1), [], .(','(TB, -(I, [])), X), X, I, []).
balance55(nil, C, T, T, A, B, A, B, X, X).
balance55(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) :- ','(balance55(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1)), balance55(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT)).
balance5(nil, C, T, T, A, B, A, B, X, X) :- balance55(nil, C, T, T, A, B, A, B, X, X).
balance5(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) :- balance55(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT).
balance(nil, -(X, X), -(A, B), -(A, B), -(.(','(nil, -(C, C)), T), T)) :- balance5(nil, C, T, T, A, B, A, B, X, X).
balance(tree(L, V, R), -(IH, IT), -(.(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T))), -(HR, TR), -(.(','(nil, -(XX0, XX0)), XX1), NT)) :- balance5(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT).

Queries:

balance(g,a).

We use the technique of [30]. With regard to the inferred argument filtering the predicates were used in the following modes:
balance_in: (b,f)
balance55_in: (b,f,f,b,b,b,b,f,f,b) (b,f,f,b,f,f,f,f,f,b) (b,f,f,b,b,b,f,f,f,b)
Transforming Prolog into the following Term Rewriting System:
Pi-finite rewrite system:
The TRS R consists of the following rules:

balance_in_ga(T, TB) → U1_ga(T, TB, balance55_in_gaaggggaag(T, XX0, XX1, [], .(','(nil, -(XX0, XX0)), XX1), [], .(','(TB, -(I, [])), X), X, I, []))
balance55_in_gaaggggaag(nil, C, T, T, A, B, A, B, X, X) → balance55_out_gaaggggaag(nil, C, T, T, A, B, A, B, X, X)
balance55_in_gaaggggaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → U2_gaaggggaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1)))
balance55_in_gaagaaaaag(nil, C, T, T, A, B, A, B, X, X) → balance55_out_gaagaaaaag(nil, C, T, T, A, B, A, B, X, X)
balance55_in_gaagaaaaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → U2_gaagaaaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1)))
U2_gaagaaaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → U3_gaagaaaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT))
U3_gaagaaaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT)) → balance55_out_gaagaaaaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT)
U2_gaaggggaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → U3_gaaggggaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagggaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT))
balance55_in_gaagggaaag(nil, C, T, T, A, B, A, B, X, X) → balance55_out_gaagggaaag(nil, C, T, T, A, B, A, B, X, X)
balance55_in_gaagggaaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → U2_gaagggaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1)))
U2_gaagggaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → U3_gaagggaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagggaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT))
U3_gaagggaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagggaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT)) → balance55_out_gaagggaaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT)
U3_gaaggggaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagggaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT)) → balance55_out_gaaggggaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT)
U1_ga(T, TB, balance55_out_gaaggggaag(T, XX0, XX1, [], .(','(nil, -(XX0, XX0)), XX1), [], .(','(TB, -(I, [])), X), X, I, [])) → balance_out_ga(T, TB)

The argument filtering Pi contains the following mapping:
balance_in_ga(x1, x2)  =  balance_in_ga(x1)
U1_ga(x1, x2, x3)  =  U1_ga(x3)
balance55_in_gaaggggaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_in_gaaggggaag(x1, x4, x5, x6, x7, x10)
-(x1, x2)  =  -
.(x1, x2)  =  .(x1)
','(x1, x2)  =  ','(x2)
nil  =  nil
balance55_out_gaaggggaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_out_gaaggggaag(x3, x8, x9)
tree(x1, x2, x3)  =  tree(x1, x2, x3)
U2_gaaggggaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U2_gaaggggaag(x3, x6, x7, x8, x18, x19)
balance55_in_gaagaaaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_in_gaagaaaaag(x1, x4, x10)
balance55_out_gaagaaaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_out_gaagaaaaag(x3, x9)
U2_gaagaaaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U2_gaagaaaaag(x3, x6, x18, x19)
U3_gaagaaaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U3_gaagaaaaag(x5, x17, x19)
U3_gaaggggaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U3_gaaggggaag(x5, x17, x19)
balance55_in_gaagggaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_in_gaagggaaag(x1, x4, x5, x6, x10)
balance55_out_gaagggaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_out_gaagggaaag(x3, x7, x8, x9)
U2_gaagggaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U2_gaagggaaag(x3, x6, x7, x8, x18, x19)
U3_gaagggaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U3_gaagggaaag(x5, x17, x19)
[]  =  []
balance_out_ga(x1, x2)  =  balance_out_ga

Infinitary Constructor Rewriting Termination of PiTRS implies Termination of Prolog



↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof

Pi-finite rewrite system:
The TRS R consists of the following rules:

balance_in_ga(T, TB) → U1_ga(T, TB, balance55_in_gaaggggaag(T, XX0, XX1, [], .(','(nil, -(XX0, XX0)), XX1), [], .(','(TB, -(I, [])), X), X, I, []))
balance55_in_gaaggggaag(nil, C, T, T, A, B, A, B, X, X) → balance55_out_gaaggggaag(nil, C, T, T, A, B, A, B, X, X)
balance55_in_gaaggggaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → U2_gaaggggaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1)))
balance55_in_gaagaaaaag(nil, C, T, T, A, B, A, B, X, X) → balance55_out_gaagaaaaag(nil, C, T, T, A, B, A, B, X, X)
balance55_in_gaagaaaaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → U2_gaagaaaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1)))
U2_gaagaaaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → U3_gaagaaaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT))
U3_gaagaaaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT)) → balance55_out_gaagaaaaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT)
U2_gaaggggaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → U3_gaaggggaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagggaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT))
balance55_in_gaagggaaag(nil, C, T, T, A, B, A, B, X, X) → balance55_out_gaagggaaag(nil, C, T, T, A, B, A, B, X, X)
balance55_in_gaagggaaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → U2_gaagggaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1)))
U2_gaagggaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → U3_gaagggaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagggaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT))
U3_gaagggaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagggaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT)) → balance55_out_gaagggaaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT)
U3_gaaggggaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagggaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT)) → balance55_out_gaaggggaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT)
U1_ga(T, TB, balance55_out_gaaggggaag(T, XX0, XX1, [], .(','(nil, -(XX0, XX0)), XX1), [], .(','(TB, -(I, [])), X), X, I, [])) → balance_out_ga(T, TB)

The argument filtering Pi contains the following mapping:
balance_in_ga(x1, x2)  =  balance_in_ga(x1)
U1_ga(x1, x2, x3)  =  U1_ga(x3)
balance55_in_gaaggggaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_in_gaaggggaag(x1, x4, x5, x6, x7, x10)
-(x1, x2)  =  -
.(x1, x2)  =  .(x1)
','(x1, x2)  =  ','(x2)
nil  =  nil
balance55_out_gaaggggaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_out_gaaggggaag(x3, x8, x9)
tree(x1, x2, x3)  =  tree(x1, x2, x3)
U2_gaaggggaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U2_gaaggggaag(x3, x6, x7, x8, x18, x19)
balance55_in_gaagaaaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_in_gaagaaaaag(x1, x4, x10)
balance55_out_gaagaaaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_out_gaagaaaaag(x3, x9)
U2_gaagaaaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U2_gaagaaaaag(x3, x6, x18, x19)
U3_gaagaaaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U3_gaagaaaaag(x5, x17, x19)
U3_gaaggggaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U3_gaaggggaag(x5, x17, x19)
balance55_in_gaagggaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_in_gaagggaaag(x1, x4, x5, x6, x10)
balance55_out_gaagggaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_out_gaagggaaag(x3, x7, x8, x9)
U2_gaagggaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U2_gaagggaaag(x3, x6, x7, x8, x18, x19)
U3_gaagggaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U3_gaagggaaag(x5, x17, x19)
[]  =  []
balance_out_ga(x1, x2)  =  balance_out_ga


Using Dependency Pairs [1,30] we result in the following initial DP problem:
Pi DP problem:
The TRS P consists of the following rules:

BALANCE_IN_GA(T, TB) → U1_GA(T, TB, balance55_in_gaaggggaag(T, XX0, XX1, [], .(','(nil, -(XX0, XX0)), XX1), [], .(','(TB, -(I, [])), X), X, I, []))
BALANCE_IN_GA(T, TB) → BALANCE55_IN_GAAGGGGAAG(T, XX0, XX1, [], .(','(nil, -(XX0, XX0)), XX1), [], .(','(TB, -(I, [])), X), X, I, [])
BALANCE55_IN_GAAGGGGAAG(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → U2_GAAGGGGAAG(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1)))
BALANCE55_IN_GAAGGGGAAG(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → BALANCE55_IN_GAAGAAAAAG(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))
BALANCE55_IN_GAAGAAAAAG(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → U2_GAAGAAAAAG(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1)))
BALANCE55_IN_GAAGAAAAAG(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → BALANCE55_IN_GAAGAAAAAG(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))
U2_GAAGAAAAAG(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → U3_GAAGAAAAAG(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT))
U2_GAAGAAAAAG(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → BALANCE55_IN_GAAGAAAAAG(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT)
U2_GAAGGGGAAG(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → U3_GAAGGGGAAG(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagggaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT))
U2_GAAGGGGAAG(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → BALANCE55_IN_GAAGGGAAAG(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT)
BALANCE55_IN_GAAGGGAAAG(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → U2_GAAGGGAAAG(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1)))
BALANCE55_IN_GAAGGGAAAG(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → BALANCE55_IN_GAAGAAAAAG(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))
U2_GAAGGGAAAG(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → U3_GAAGGGAAAG(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagggaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT))
U2_GAAGGGAAAG(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → BALANCE55_IN_GAAGGGAAAG(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT)

The TRS R consists of the following rules:

balance_in_ga(T, TB) → U1_ga(T, TB, balance55_in_gaaggggaag(T, XX0, XX1, [], .(','(nil, -(XX0, XX0)), XX1), [], .(','(TB, -(I, [])), X), X, I, []))
balance55_in_gaaggggaag(nil, C, T, T, A, B, A, B, X, X) → balance55_out_gaaggggaag(nil, C, T, T, A, B, A, B, X, X)
balance55_in_gaaggggaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → U2_gaaggggaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1)))
balance55_in_gaagaaaaag(nil, C, T, T, A, B, A, B, X, X) → balance55_out_gaagaaaaag(nil, C, T, T, A, B, A, B, X, X)
balance55_in_gaagaaaaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → U2_gaagaaaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1)))
U2_gaagaaaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → U3_gaagaaaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT))
U3_gaagaaaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT)) → balance55_out_gaagaaaaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT)
U2_gaaggggaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → U3_gaaggggaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagggaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT))
balance55_in_gaagggaaag(nil, C, T, T, A, B, A, B, X, X) → balance55_out_gaagggaaag(nil, C, T, T, A, B, A, B, X, X)
balance55_in_gaagggaaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → U2_gaagggaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1)))
U2_gaagggaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → U3_gaagggaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagggaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT))
U3_gaagggaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagggaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT)) → balance55_out_gaagggaaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT)
U3_gaaggggaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagggaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT)) → balance55_out_gaaggggaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT)
U1_ga(T, TB, balance55_out_gaaggggaag(T, XX0, XX1, [], .(','(nil, -(XX0, XX0)), XX1), [], .(','(TB, -(I, [])), X), X, I, [])) → balance_out_ga(T, TB)

The argument filtering Pi contains the following mapping:
balance_in_ga(x1, x2)  =  balance_in_ga(x1)
U1_ga(x1, x2, x3)  =  U1_ga(x3)
balance55_in_gaaggggaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_in_gaaggggaag(x1, x4, x5, x6, x7, x10)
-(x1, x2)  =  -
.(x1, x2)  =  .(x1)
','(x1, x2)  =  ','(x2)
nil  =  nil
balance55_out_gaaggggaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_out_gaaggggaag(x3, x8, x9)
tree(x1, x2, x3)  =  tree(x1, x2, x3)
U2_gaaggggaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U2_gaaggggaag(x3, x6, x7, x8, x18, x19)
balance55_in_gaagaaaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_in_gaagaaaaag(x1, x4, x10)
balance55_out_gaagaaaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_out_gaagaaaaag(x3, x9)
U2_gaagaaaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U2_gaagaaaaag(x3, x6, x18, x19)
U3_gaagaaaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U3_gaagaaaaag(x5, x17, x19)
U3_gaaggggaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U3_gaaggggaag(x5, x17, x19)
balance55_in_gaagggaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_in_gaagggaaag(x1, x4, x5, x6, x10)
balance55_out_gaagggaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_out_gaagggaaag(x3, x7, x8, x9)
U2_gaagggaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U2_gaagggaaag(x3, x6, x7, x8, x18, x19)
U3_gaagggaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U3_gaagggaaag(x5, x17, x19)
[]  =  []
balance_out_ga(x1, x2)  =  balance_out_ga
U3_GAAGGGGAAG(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U3_GAAGGGGAAG(x5, x17, x19)
U3_GAAGGGAAAG(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U3_GAAGGGAAAG(x5, x17, x19)
U3_GAAGAAAAAG(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U3_GAAGAAAAAG(x5, x17, x19)
BALANCE_IN_GA(x1, x2)  =  BALANCE_IN_GA(x1)
U2_GAAGAAAAAG(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U2_GAAGAAAAAG(x3, x6, x18, x19)
U2_GAAGGGGAAG(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U2_GAAGGGGAAG(x3, x6, x7, x8, x18, x19)
U2_GAAGGGAAAG(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U2_GAAGGGAAAG(x3, x6, x7, x8, x18, x19)
BALANCE55_IN_GAAGGGAAAG(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  BALANCE55_IN_GAAGGGAAAG(x1, x4, x5, x6, x10)
BALANCE55_IN_GAAGGGGAAG(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  BALANCE55_IN_GAAGGGGAAG(x1, x4, x5, x6, x7, x10)
U1_GA(x1, x2, x3)  =  U1_GA(x3)
BALANCE55_IN_GAAGAAAAAG(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  BALANCE55_IN_GAAGAAAAAG(x1, x4, x10)

We have to consider all (P,R,Pi)-chains

↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof

Pi DP problem:
The TRS P consists of the following rules:

BALANCE_IN_GA(T, TB) → U1_GA(T, TB, balance55_in_gaaggggaag(T, XX0, XX1, [], .(','(nil, -(XX0, XX0)), XX1), [], .(','(TB, -(I, [])), X), X, I, []))
BALANCE_IN_GA(T, TB) → BALANCE55_IN_GAAGGGGAAG(T, XX0, XX1, [], .(','(nil, -(XX0, XX0)), XX1), [], .(','(TB, -(I, [])), X), X, I, [])
BALANCE55_IN_GAAGGGGAAG(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → U2_GAAGGGGAAG(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1)))
BALANCE55_IN_GAAGGGGAAG(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → BALANCE55_IN_GAAGAAAAAG(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))
BALANCE55_IN_GAAGAAAAAG(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → U2_GAAGAAAAAG(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1)))
BALANCE55_IN_GAAGAAAAAG(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → BALANCE55_IN_GAAGAAAAAG(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))
U2_GAAGAAAAAG(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → U3_GAAGAAAAAG(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT))
U2_GAAGAAAAAG(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → BALANCE55_IN_GAAGAAAAAG(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT)
U2_GAAGGGGAAG(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → U3_GAAGGGGAAG(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagggaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT))
U2_GAAGGGGAAG(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → BALANCE55_IN_GAAGGGAAAG(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT)
BALANCE55_IN_GAAGGGAAAG(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → U2_GAAGGGAAAG(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1)))
BALANCE55_IN_GAAGGGAAAG(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → BALANCE55_IN_GAAGAAAAAG(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))
U2_GAAGGGAAAG(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → U3_GAAGGGAAAG(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagggaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT))
U2_GAAGGGAAAG(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → BALANCE55_IN_GAAGGGAAAG(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT)

The TRS R consists of the following rules:

balance_in_ga(T, TB) → U1_ga(T, TB, balance55_in_gaaggggaag(T, XX0, XX1, [], .(','(nil, -(XX0, XX0)), XX1), [], .(','(TB, -(I, [])), X), X, I, []))
balance55_in_gaaggggaag(nil, C, T, T, A, B, A, B, X, X) → balance55_out_gaaggggaag(nil, C, T, T, A, B, A, B, X, X)
balance55_in_gaaggggaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → U2_gaaggggaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1)))
balance55_in_gaagaaaaag(nil, C, T, T, A, B, A, B, X, X) → balance55_out_gaagaaaaag(nil, C, T, T, A, B, A, B, X, X)
balance55_in_gaagaaaaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → U2_gaagaaaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1)))
U2_gaagaaaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → U3_gaagaaaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT))
U3_gaagaaaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT)) → balance55_out_gaagaaaaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT)
U2_gaaggggaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → U3_gaaggggaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagggaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT))
balance55_in_gaagggaaag(nil, C, T, T, A, B, A, B, X, X) → balance55_out_gaagggaaag(nil, C, T, T, A, B, A, B, X, X)
balance55_in_gaagggaaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → U2_gaagggaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1)))
U2_gaagggaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → U3_gaagggaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagggaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT))
U3_gaagggaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagggaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT)) → balance55_out_gaagggaaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT)
U3_gaaggggaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagggaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT)) → balance55_out_gaaggggaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT)
U1_ga(T, TB, balance55_out_gaaggggaag(T, XX0, XX1, [], .(','(nil, -(XX0, XX0)), XX1), [], .(','(TB, -(I, [])), X), X, I, [])) → balance_out_ga(T, TB)

The argument filtering Pi contains the following mapping:
balance_in_ga(x1, x2)  =  balance_in_ga(x1)
U1_ga(x1, x2, x3)  =  U1_ga(x3)
balance55_in_gaaggggaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_in_gaaggggaag(x1, x4, x5, x6, x7, x10)
-(x1, x2)  =  -
.(x1, x2)  =  .(x1)
','(x1, x2)  =  ','(x2)
nil  =  nil
balance55_out_gaaggggaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_out_gaaggggaag(x3, x8, x9)
tree(x1, x2, x3)  =  tree(x1, x2, x3)
U2_gaaggggaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U2_gaaggggaag(x3, x6, x7, x8, x18, x19)
balance55_in_gaagaaaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_in_gaagaaaaag(x1, x4, x10)
balance55_out_gaagaaaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_out_gaagaaaaag(x3, x9)
U2_gaagaaaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U2_gaagaaaaag(x3, x6, x18, x19)
U3_gaagaaaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U3_gaagaaaaag(x5, x17, x19)
U3_gaaggggaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U3_gaaggggaag(x5, x17, x19)
balance55_in_gaagggaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_in_gaagggaaag(x1, x4, x5, x6, x10)
balance55_out_gaagggaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_out_gaagggaaag(x3, x7, x8, x9)
U2_gaagggaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U2_gaagggaaag(x3, x6, x7, x8, x18, x19)
U3_gaagggaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U3_gaagggaaag(x5, x17, x19)
[]  =  []
balance_out_ga(x1, x2)  =  balance_out_ga
U3_GAAGGGGAAG(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U3_GAAGGGGAAG(x5, x17, x19)
U3_GAAGGGAAAG(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U3_GAAGGGAAAG(x5, x17, x19)
U3_GAAGAAAAAG(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U3_GAAGAAAAAG(x5, x17, x19)
BALANCE_IN_GA(x1, x2)  =  BALANCE_IN_GA(x1)
U2_GAAGAAAAAG(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U2_GAAGAAAAAG(x3, x6, x18, x19)
U2_GAAGGGGAAG(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U2_GAAGGGGAAG(x3, x6, x7, x8, x18, x19)
U2_GAAGGGAAAG(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U2_GAAGGGAAAG(x3, x6, x7, x8, x18, x19)
BALANCE55_IN_GAAGGGAAAG(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  BALANCE55_IN_GAAGGGAAAG(x1, x4, x5, x6, x10)
BALANCE55_IN_GAAGGGGAAG(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  BALANCE55_IN_GAAGGGGAAG(x1, x4, x5, x6, x7, x10)
U1_GA(x1, x2, x3)  =  U1_GA(x3)
BALANCE55_IN_GAAGAAAAAG(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  BALANCE55_IN_GAAGAAAAAG(x1, x4, x10)

We have to consider all (P,R,Pi)-chains
The approximation of the Dependency Graph [30] contains 2 SCCs with 9 less nodes.

↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
                ↳ UsableRulesProof
              ↳ PiDP

Pi DP problem:
The TRS P consists of the following rules:

U2_GAAGAAAAAG(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → BALANCE55_IN_GAAGAAAAAG(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT)
BALANCE55_IN_GAAGAAAAAG(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → U2_GAAGAAAAAG(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1)))
BALANCE55_IN_GAAGAAAAAG(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → BALANCE55_IN_GAAGAAAAAG(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))

The TRS R consists of the following rules:

balance_in_ga(T, TB) → U1_ga(T, TB, balance55_in_gaaggggaag(T, XX0, XX1, [], .(','(nil, -(XX0, XX0)), XX1), [], .(','(TB, -(I, [])), X), X, I, []))
balance55_in_gaaggggaag(nil, C, T, T, A, B, A, B, X, X) → balance55_out_gaaggggaag(nil, C, T, T, A, B, A, B, X, X)
balance55_in_gaaggggaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → U2_gaaggggaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1)))
balance55_in_gaagaaaaag(nil, C, T, T, A, B, A, B, X, X) → balance55_out_gaagaaaaag(nil, C, T, T, A, B, A, B, X, X)
balance55_in_gaagaaaaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → U2_gaagaaaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1)))
U2_gaagaaaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → U3_gaagaaaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT))
U3_gaagaaaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT)) → balance55_out_gaagaaaaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT)
U2_gaaggggaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → U3_gaaggggaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagggaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT))
balance55_in_gaagggaaag(nil, C, T, T, A, B, A, B, X, X) → balance55_out_gaagggaaag(nil, C, T, T, A, B, A, B, X, X)
balance55_in_gaagggaaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → U2_gaagggaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1)))
U2_gaagggaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → U3_gaagggaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagggaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT))
U3_gaagggaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagggaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT)) → balance55_out_gaagggaaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT)
U3_gaaggggaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagggaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT)) → balance55_out_gaaggggaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT)
U1_ga(T, TB, balance55_out_gaaggggaag(T, XX0, XX1, [], .(','(nil, -(XX0, XX0)), XX1), [], .(','(TB, -(I, [])), X), X, I, [])) → balance_out_ga(T, TB)

The argument filtering Pi contains the following mapping:
balance_in_ga(x1, x2)  =  balance_in_ga(x1)
U1_ga(x1, x2, x3)  =  U1_ga(x3)
balance55_in_gaaggggaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_in_gaaggggaag(x1, x4, x5, x6, x7, x10)
-(x1, x2)  =  -
.(x1, x2)  =  .(x1)
','(x1, x2)  =  ','(x2)
nil  =  nil
balance55_out_gaaggggaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_out_gaaggggaag(x3, x8, x9)
tree(x1, x2, x3)  =  tree(x1, x2, x3)
U2_gaaggggaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U2_gaaggggaag(x3, x6, x7, x8, x18, x19)
balance55_in_gaagaaaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_in_gaagaaaaag(x1, x4, x10)
balance55_out_gaagaaaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_out_gaagaaaaag(x3, x9)
U2_gaagaaaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U2_gaagaaaaag(x3, x6, x18, x19)
U3_gaagaaaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U3_gaagaaaaag(x5, x17, x19)
U3_gaaggggaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U3_gaaggggaag(x5, x17, x19)
balance55_in_gaagggaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_in_gaagggaaag(x1, x4, x5, x6, x10)
balance55_out_gaagggaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_out_gaagggaaag(x3, x7, x8, x9)
U2_gaagggaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U2_gaagggaaag(x3, x6, x7, x8, x18, x19)
U3_gaagggaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U3_gaagggaaag(x5, x17, x19)
[]  =  []
balance_out_ga(x1, x2)  =  balance_out_ga
U2_GAAGAAAAAG(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U2_GAAGAAAAAG(x3, x6, x18, x19)
BALANCE55_IN_GAAGAAAAAG(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  BALANCE55_IN_GAAGAAAAAG(x1, x4, x10)

We have to consider all (P,R,Pi)-chains
For (infinitary) constructor rewriting [30] we can delete all non-usable rules from R.

↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
              ↳ PiDP

Pi DP problem:
The TRS P consists of the following rules:

U2_GAAGAAAAAG(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → BALANCE55_IN_GAAGAAAAAG(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT)
BALANCE55_IN_GAAGAAAAAG(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → U2_GAAGAAAAAG(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1)))
BALANCE55_IN_GAAGAAAAAG(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → BALANCE55_IN_GAAGAAAAAG(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))

The TRS R consists of the following rules:

balance55_in_gaagaaaaag(nil, C, T, T, A, B, A, B, X, X) → balance55_out_gaagaaaaag(nil, C, T, T, A, B, A, B, X, X)
balance55_in_gaagaaaaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → U2_gaagaaaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1)))
U2_gaagaaaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → U3_gaagaaaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT))
U3_gaagaaaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT)) → balance55_out_gaagaaaaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT)

The argument filtering Pi contains the following mapping:
-(x1, x2)  =  -
.(x1, x2)  =  .(x1)
','(x1, x2)  =  ','(x2)
nil  =  nil
tree(x1, x2, x3)  =  tree(x1, x2, x3)
balance55_in_gaagaaaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_in_gaagaaaaag(x1, x4, x10)
balance55_out_gaagaaaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_out_gaagaaaaag(x3, x9)
U2_gaagaaaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U2_gaagaaaaag(x3, x6, x18, x19)
U3_gaagaaaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U3_gaagaaaaag(x5, x17, x19)
U2_GAAGAAAAAG(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U2_GAAGAAAAAG(x3, x6, x18, x19)
BALANCE55_IN_GAAGAAAAAG(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  BALANCE55_IN_GAAGAAAAAG(x1, x4, x10)

We have to consider all (P,R,Pi)-chains
Transforming (infinitary) constructor rewriting Pi-DP problem [30] into ordinary QDP problem [15] by application of Pi.

↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ QDPSizeChangeProof
              ↳ PiDP

Q DP problem:
The TRS P consists of the following rules:

BALANCE55_IN_GAAGAAAAAG(tree(L, V, R), NT, IT) → U2_GAAGAAAAAG(R, NT, IT, balance55_in_gaagaaaaag(L, .(','(-)), .(V)))
U2_GAAGAAAAAG(R, NT, IT, balance55_out_gaagaaaaag(XX1, IH)) → BALANCE55_IN_GAAGAAAAAG(R, NT, IT)
BALANCE55_IN_GAAGAAAAAG(tree(L, V, R), NT, IT) → BALANCE55_IN_GAAGAAAAAG(L, .(','(-)), .(V))

The TRS R consists of the following rules:

balance55_in_gaagaaaaag(nil, T, X) → balance55_out_gaagaaaaag(T, X)
balance55_in_gaagaaaaag(tree(L, V, R), NT, IT) → U2_gaagaaaaag(R, NT, IT, balance55_in_gaagaaaaag(L, .(','(-)), .(V)))
U2_gaagaaaaag(R, NT, IT, balance55_out_gaagaaaaag(XX1, IH)) → U3_gaagaaaaag(XX1, IH, balance55_in_gaagaaaaag(R, NT, IT))
U3_gaagaaaaag(XX1, IH, balance55_out_gaagaaaaag(XX3, IT1)) → balance55_out_gaagaaaaag(XX1, IH)

The set Q consists of the following terms:

balance55_in_gaagaaaaag(x0, x1, x2)
U2_gaagaaaaag(x0, x1, x2, x3)
U3_gaagaaaaag(x0, x1, x2)

We have to consider all (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: 



↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof

Pi DP problem:
The TRS P consists of the following rules:

U2_GAAGGGAAAG(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → BALANCE55_IN_GAAGGGAAAG(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT)
BALANCE55_IN_GAAGGGAAAG(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → U2_GAAGGGAAAG(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1)))

The TRS R consists of the following rules:

balance_in_ga(T, TB) → U1_ga(T, TB, balance55_in_gaaggggaag(T, XX0, XX1, [], .(','(nil, -(XX0, XX0)), XX1), [], .(','(TB, -(I, [])), X), X, I, []))
balance55_in_gaaggggaag(nil, C, T, T, A, B, A, B, X, X) → balance55_out_gaaggggaag(nil, C, T, T, A, B, A, B, X, X)
balance55_in_gaaggggaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → U2_gaaggggaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1)))
balance55_in_gaagaaaaag(nil, C, T, T, A, B, A, B, X, X) → balance55_out_gaagaaaaag(nil, C, T, T, A, B, A, B, X, X)
balance55_in_gaagaaaaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → U2_gaagaaaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1)))
U2_gaagaaaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → U3_gaagaaaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT))
U3_gaagaaaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT)) → balance55_out_gaagaaaaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT)
U2_gaaggggaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → U3_gaaggggaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagggaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT))
balance55_in_gaagggaaag(nil, C, T, T, A, B, A, B, X, X) → balance55_out_gaagggaaag(nil, C, T, T, A, B, A, B, X, X)
balance55_in_gaagggaaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → U2_gaagggaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1)))
U2_gaagggaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → U3_gaagggaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagggaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT))
U3_gaagggaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagggaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT)) → balance55_out_gaagggaaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT)
U3_gaaggggaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagggaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT)) → balance55_out_gaaggggaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT)
U1_ga(T, TB, balance55_out_gaaggggaag(T, XX0, XX1, [], .(','(nil, -(XX0, XX0)), XX1), [], .(','(TB, -(I, [])), X), X, I, [])) → balance_out_ga(T, TB)

The argument filtering Pi contains the following mapping:
balance_in_ga(x1, x2)  =  balance_in_ga(x1)
U1_ga(x1, x2, x3)  =  U1_ga(x3)
balance55_in_gaaggggaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_in_gaaggggaag(x1, x4, x5, x6, x7, x10)
-(x1, x2)  =  -
.(x1, x2)  =  .(x1)
','(x1, x2)  =  ','(x2)
nil  =  nil
balance55_out_gaaggggaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_out_gaaggggaag(x3, x8, x9)
tree(x1, x2, x3)  =  tree(x1, x2, x3)
U2_gaaggggaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U2_gaaggggaag(x3, x6, x7, x8, x18, x19)
balance55_in_gaagaaaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_in_gaagaaaaag(x1, x4, x10)
balance55_out_gaagaaaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_out_gaagaaaaag(x3, x9)
U2_gaagaaaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U2_gaagaaaaag(x3, x6, x18, x19)
U3_gaagaaaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U3_gaagaaaaag(x5, x17, x19)
U3_gaaggggaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U3_gaaggggaag(x5, x17, x19)
balance55_in_gaagggaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_in_gaagggaaag(x1, x4, x5, x6, x10)
balance55_out_gaagggaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_out_gaagggaaag(x3, x7, x8, x9)
U2_gaagggaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U2_gaagggaaag(x3, x6, x7, x8, x18, x19)
U3_gaagggaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U3_gaagggaaag(x5, x17, x19)
[]  =  []
balance_out_ga(x1, x2)  =  balance_out_ga
U2_GAAGGGAAAG(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U2_GAAGGGAAAG(x3, x6, x7, x8, x18, x19)
BALANCE55_IN_GAAGGGAAAG(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  BALANCE55_IN_GAAGGGAAAG(x1, x4, x5, x6, x10)

We have to consider all (P,R,Pi)-chains
For (infinitary) constructor rewriting [30] we can delete all non-usable rules from R.

↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof

Pi DP problem:
The TRS P consists of the following rules:

U2_GAAGGGAAAG(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → BALANCE55_IN_GAAGGGAAAG(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT)
BALANCE55_IN_GAAGGGAAAG(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → U2_GAAGGGAAAG(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1)))

The TRS R consists of the following rules:

balance55_in_gaagaaaaag(nil, C, T, T, A, B, A, B, X, X) → balance55_out_gaagaaaaag(nil, C, T, T, A, B, A, B, X, X)
balance55_in_gaagaaaaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT) → U2_gaagaaaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1)))
U2_gaagaaaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(L, XX0, XX1, .(','(nil, -(XX2, XX2)), XX3), HR1, TR1, H, T, IH, .(V, IT1))) → U3_gaagaaaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_in_gaagaaaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT))
U3_gaagaaaaag(L, V, R, XX0, XX1, NT, HR, TR, LB, VB, RB, A, D, H, X, T, IH, IT, balance55_out_gaagaaaaag(R, XX2, XX3, NT, HR, TR, HR1, TR1, IT1, IT)) → balance55_out_gaagaaaaag(tree(L, V, R), XX0, XX1, NT, HR, TR, .(','(tree(LB, VB, RB), -(A, D)), H), .(','(LB, -(A, .(VB, X))), .(','(RB, -(X, D)), T)), IH, IT)

The argument filtering Pi contains the following mapping:
-(x1, x2)  =  -
.(x1, x2)  =  .(x1)
','(x1, x2)  =  ','(x2)
nil  =  nil
tree(x1, x2, x3)  =  tree(x1, x2, x3)
balance55_in_gaagaaaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_in_gaagaaaaag(x1, x4, x10)
balance55_out_gaagaaaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  balance55_out_gaagaaaaag(x3, x9)
U2_gaagaaaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U2_gaagaaaaag(x3, x6, x18, x19)
U3_gaagaaaaag(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U3_gaagaaaaag(x5, x17, x19)
U2_GAAGGGAAAG(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)  =  U2_GAAGGGAAAG(x3, x6, x7, x8, x18, x19)
BALANCE55_IN_GAAGGGAAAG(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)  =  BALANCE55_IN_GAAGGGAAAG(x1, x4, x5, x6, x10)

We have to consider all (P,R,Pi)-chains
Transforming (infinitary) constructor rewriting Pi-DP problem [30] into ordinary QDP problem [15] by application of Pi.

↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ QDPSizeChangeProof

Q DP problem:
The TRS P consists of the following rules:

BALANCE55_IN_GAAGGGAAAG(tree(L, V, R), NT, HR, TR, IT) → U2_GAAGGGAAAG(R, NT, HR, TR, IT, balance55_in_gaagaaaaag(L, .(','(-)), .(V)))
U2_GAAGGGAAAG(R, NT, HR, TR, IT, balance55_out_gaagaaaaag(XX1, IH)) → BALANCE55_IN_GAAGGGAAAG(R, NT, HR, TR, IT)

The TRS R consists of the following rules:

balance55_in_gaagaaaaag(nil, T, X) → balance55_out_gaagaaaaag(T, X)
balance55_in_gaagaaaaag(tree(L, V, R), NT, IT) → U2_gaagaaaaag(R, NT, IT, balance55_in_gaagaaaaag(L, .(','(-)), .(V)))
U2_gaagaaaaag(R, NT, IT, balance55_out_gaagaaaaag(XX1, IH)) → U3_gaagaaaaag(XX1, IH, balance55_in_gaagaaaaag(R, NT, IT))
U3_gaagaaaaag(XX1, IH, balance55_out_gaagaaaaag(XX3, IT1)) → balance55_out_gaagaaaaag(XX1, IH)

The set Q consists of the following terms:

balance55_in_gaagaaaaag(x0, x1, x2)
U2_gaagaaaaag(x0, x1, x2, x3)
U3_gaagaaaaag(x0, x1, x2)

We have to consider all (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: